home *** CD-ROM | disk | FTP | other *** search
Text File | 1994-01-31 | 72.0 KB | 2,596 lines | [ TEXT/PJMM]
unit Analysis; {Analysis routines used by the Image program} interface uses QuickDraw, Palettes, PrintTraps, globals, Utilities, LeastSquares, Graphics, file1, file2, Ellipse, Lut; procedure DoHistogram; procedure GetRectHistogram; function SetupMask: boolean; procedure GetHistogram; procedure ShowContinuousHistogram; procedure ComputeResults; procedure FindThresholdingMode; procedure Measure; procedure UpdateRoiLineWidth; procedure DoProfilePlotOptions; procedure ShowResults; procedure PlotDensityProfile; procedure SetScale; procedure Calibrate; procedure ResetCounter; procedure DoMeasurementOptions; procedure DoPoints (event: EventRecord); procedure FindAngle (event: EventRecord); procedure SaveBlankField; procedure UndoLastMeasurement (DisplayResults: boolean); procedure MarkSelection (count: integer); procedure AutoOutline (start: point); procedure RedoMeasurement; procedure DeleteMeasurement; procedure AnalyzeParticles; procedure MakeNonStraightLineRoi (RoiKind: RoiTypeType); implementation const UnitsPopUpID = 6; var WandMode: (LUTMode, GrayMapMode, BinaryMode); GrayMapThreshold: integer; InfoForRedirect: InfoPtr; UnitsKind: UnitsType; {$PUSH} {$D-} procedure DoHistogramOfLine (data: ptr; var histogram: HistogramType; width: LongInt); {} {VAR} { line:LinePtr;} { i,value:integer;} {BEGIN} { line:=LinePtr(data);} { FOR i:=0 TO width-1 DO BEGIN} { value:=line^[i];} { histogram[value]:=histogram[value]+1;} { END;} {} {a0=data} {a1=histogram} {d0=width} {d1=pixel value} inline $4E56, $0000, { link a6,#0} $48E7, $C0C0, { movem.l a0-a1/d0-d1,-(sp)} $206E, $000C, { move.l 12(a6),a0} $226E, $0008, { move.l 8(a6),a1} $202E, $0004, { move.l 4(a6),d0} $5380, { subq.l #1,d0} $4281, {L clr.l d1} $1218, { move.b (a0)+,d1} $E541, { asl.w #2,d1} $52B1, $1800, { addq.l #1,0(a1,d1.l)} $51C8, $FFF4, { dbra d0,L} $4CDF, $0303, { movem.l (sp)+,a0-a1/d0-d1} $4E5E, { unlk a6} $DEFC, $000C; { add.w #12,sp} {END;} procedure GetRectHistogram; var width, i, NumberOfLines: integer; offset: LongInt; p: ptr; begin if TooWide then exit(GetRectHistogram); ShowWatch; for i := 0 to 255 do Histogram[i] := 0; with info^.RoiRect, info^ do begin offset := LongInt(top) * BytesPerRow + left; p := ptr(ord4(PicBaseAddr) + offset); width := right - left; NumberOfLines := bottom - top; end; if width > 0 then for i := 1 to NumberOfLines do begin DoHistogramOfLine(p, histogram, width); p := ptr(ord4(p) + info^.BytesPerRow); end end; function SetupMask: boolean; {Creates a mask in the undo buffer for operating} {on non-rectangular selections .} var tPort: GrafPtr; SaveInfo: InfoPtr; begin if NoUndo then begin SetupMask := false; exit(SetupMask) end; SetupUndoInfoRec; SaveInfo := Info; Info := UndoInfo; GetPort(tPort); with Info^ do begin SetPort(GrafPtr(osPort)); pmForeColor(BlackIndex); pmBackColor(WhiteIndex); PenNormal; EraseRect(RoiRect); PaintRgn(roiRgn); end; SetPort(tPort); Info := SaveInfo; SetupMask := true; end; procedure SetupRedirectedSampling; var info1, info2: InfoPtr; begin InfoForRedirect := nil; if nPics <> 2 then begin PutMessage('There must be exactly two image windows open to do redirected sampling.'); AnalyzingParticles := false; exit(SetupRedirectedSampling); end; Info1 := pointer(WindowPeek(PicWindow[1])^.RefCon); Info2 := pointer(WindowPeek(PicWindow[2])^.RefCon); if not EqualRect(info1^.PicRect, info2^.PicRect) then begin PutMessage('The image windows must be exactly the same size to do redirected sampling.'); AnalyzingParticles := false; exit(SetupRedirectedSampling); end; if info = info1 then InfoForRedirect := info2 else InfoForRedirect := info1; end; procedure GetHistogram; var MaskLine, DataLine: LineType; width, i, vloc: integer; sum, sum2, count, OverFlows: LongInt; SaveInfo: InfoPtr; value: LongInt; trect: rect; begin if TooWide then exit(GetHistogram); ShowWatch; if RedirectSampling then SetupRedirectedSampling else InfoForRedirect := nil; if not SetupMask then beep; SaveInfo := Info; for i := 0 to 255 do Histogram[i] := 0; if FitEllipse then ResetSums; trect := info^.RoiRect; with trect do begin width := right - left; for vloc := top to bottom - 1 do begin if InfoForRedirect <> nil then Info := InfoForRedirect else Info := SaveInfo; GetLine(left, vloc, width, DataLine); Info := UndoInfo; GetLine(left, vloc, width, MaskLine); if FitEllipse then ComputeSums(vloc - top, width, MaskLine); for i := 0 to width - 1 do if MaskLine[i] = BlackIndex then begin value := DataLine[i]; histogram[value] := histogram[value] + 1; end; end; end; Info := SaveInfo; if not AnalyzingParticles then SetupUndo; {Needed for drawing "marching ants".} end; procedure ComputeResults; var MaxCount, icount, isum, n: LongInt; i: integer; sum, sum2, ri, rcount, tSD, rmode, xc, yc: extended; Major, Minor, EllipseAngle, hcenter, vcenter, calValue: extended; MinCalibratedValue, MaxCalibratedValue, CalibratedMean: extended; IgnoreThresholding: boolean; ulength, clength: real; begin with info^, results do begin case ThresholdingMode of DensitySlice: begin MinIndex := SliceStart; MaxIndex := SliceEnd; end; GrayMapThresholding: begin MinIndex := GrayMapThreshold; MaxIndex := 255; end; BinaryImage: begin MinIndex := BlackIndex; MaxIndex := BlackIndex; end; NoThresholding: begin MinIndex := 0; MaxIndex := 255; end; end; IgnoreThresholding := RedirectSampling or (IncludeHoles and (AnalyzingParticles or (CurrentTool = Wand))); if IgnoreThresholding then begin MinIndex := 0; MaxIndex := 255; end; while (histogram[MinIndex] = 0) and (MinIndex < 255) do MinIndex := MinIndex + 1; while (histogram[MaxIndex] = 0) and (MaxIndex > 0) do MaxIndex := MaxIndex - 1; MaxCount := 0; sum := 0.0; isum := 0; sum2 := 0.0; n := 0; minCalibratedValue := 10e100; maxCalibratedValue := -10e100; rmode := 0.0; imode := 0; for i := MinIndex to MaxIndex do begin calValue := cvalue[i]; icount := histogram[i]; rcount := icount; sum := sum + rcount * calValue; isum := isum + icount * i; ri := i; sum2 := sum2 + sqr(calValue) * rcount; n := n + icount; if icount > MaxCount then begin MaxCount := icount; rmode := cvalue[i]; imode := i end; if calValue < minCalibratedValue then minCalibratedValue := calValue; if calValue > maxCalibratedValue then maxCalibratedValue := calValue; end; if ContinuousHistoGram then exit(ComputeResults); if n = 0 then begin minCalibratedValue := 0.0; maxCalibratedValue := 0.0; end; if n > 0 then begin CalibratedMean := sum / n; UncalibratedMean := isum / n end else begin CalibratedMean := 0.0; UncalibratedMean := 0.0 end; IncrementCounter; mean^[mCount] := CalibratedMean; mMin^[mCount] := minCalibratedValue; mMax^[mCount] := maxCalibratedValue; if mCount <= MaxStandards then umean[mCount] := UncalibratedMean; if (n > 0) and (CalibratedMean > 0.0) then begin rcount := n; tSD := (rcount * Sum2 - sqr(sum)) / rcount; if tSD > 0.0 then tSD := sqrt(tSD / (rcount - 1.0)) else tSD := 0.0 end else tSD := 0.0; sd^[mCount] := tSD; with info^.RoiRect do begin xc := left + (right - left) / 2; yc := top + (bottom - top) / 2; if InvertYCoordinates then yc := PicRect.bottom - yc; if SpatiallyCalibrated then begin xc := xc / xSpatialScale; yc := yc / ySpatialScale; end; xcenter^[mCount] := xc; ycenter^[mCount] := yc; end; PixelCount^[mCount] := n; ulength := 0.0; clength := 0.0; with RoiRect do case RoiType of RectRoi: begin uLength := ((right - left) + (bottom - top)) * 2.0; cLength := uLength; if SpatiallyCalibrated then cLength := ((right - left) / xSpatialScale + (bottom - top) / ySpatialScale) * 2.0; end; OvalRoi: begin uLength := pi * ((right - left) + (bottom - top)) / 2.0; cLength := uLength; if SpatiallyCalibrated then cLength := pi * ((right - left) / xSpatialScale + (bottom - top) / ySpatialScale) / 2.0; end; LineRoi, SegLineRoi, FreeLineRoi: begin GetLengthOrPerimeter(ulength, clength); nLengths := nLengths + 1; end; PolygonRoi, FreehandRoi: if (LengthM in Measurements) or (nLengths > 0) or WandAdjustAreas then GetLengthOrPerimeter(ulength, clength); otherwise end; if SpatiallyCalibrated then plength^[mCount] := cLength else plength^[mcount] := uLength; if SpatiallyCalibrated then mArea^[mCount] := n / (xSpatialScale * ySpatialScale) else mArea^[mCount] := n; mode^[mCount] := rmode; if FitEllipse and ((RoiType = PolygonRoi) or (RoiType = FreehandRoi) or (RoiType = LineRoi) or (RoiType = FreeLineRoi) or (RoiType = SegLineRoi)) then begin GetEllipseParam(Major, Minor, EllipseAngle, xc, yc); if InvertYCoordinates then yc := PicRect.bottom - yc; if SpatiallyCalibrated then begin Major := Major / xSpatialScale; Minor := Minor / ySpatialScale; xc := xc / xSpatialScale; yc := yc / ySpatialScale; end; MajorAxis^[mCount] := Major * 2.0; MinorAxis^[mCount] := Minor * 2.0; orientation^[mCount] := EllipseAngle; xcenter^[mCount] := xc; ycenter^[mCount] := yc; end else if RoiType = OvalRoi then with RoiRect do begin Major := right - left; Minor := bottom - top; if SpatiallyCalibrated then begin Major := Major / xSpatialScale; Minor := Minor / ySpatialScale; end; MajorAxis^[mCount] := Major; MinorAxis^[mCount] := Minor; orientation^[mCount] := 0.0; end else begin MajorAxis^[mCount] := 0.0; MinorAxis^[mCount] := 0.0; orientation^[mCount] := 0.0; end; end; {with} measuring := true; ValuesMessage := ''; end; procedure FindThresholdingMode; begin with info^ do begin if DensitySlicing then ThresholdingMode := DensitySlice else if thresholding then begin ThresholdingMode := GrayMapThresholding; GrayMapThreshold := ColorStart; if GrayMapThreshold < 0 then GrayMapThreshold := 0; if GrayMapThreshold > 255 then GrayMapThreshold := 255; end else if BinaryPic then ThresholdingMode := BinaryImage else ThresholdingMode := NoThresholding; end; end; procedure Measure; var AutoSelectAll: boolean; SaveN: integer; begin if NotInBounds then exit(Measure); with info^ do begin FindThresholdingMode; if ThresholdingMode = BinaryImage then ThresholdingMode := NoThresholding; AutoSelectAll := not RoiShowing; if AutoSelectAll then SelectAll(false); if (RoiType = RectRoi) and (not RedirectSampling) then GetRectHistogram else GetHistogram; if MeasurementToRedo > 0 then begin SaveN := mCount; mCount := MeasurementToRedo - 1; ComputeResults; ShowValues; mCount := SaveN; MeasurementToRedo := 0; UpdateList; end else begin ComputeResults; ShowValues; AppendResults; if RoiType = LineRoi then if nLengths = 1 then if not (LengthM in Measurements) then UpdateList; end; RoiShowing := true; WhatToUndo := UndoMeasurement; if AutoSelectAll then KillRoi; UpdateScreen(OldRoiRect); end; end; procedure ShowHistogram; var htop: integer; tport: GrafPtr; hrect, prect, srect: rect; FirstTime: boolean; begin GetPort(tPort); FirstTime := HistoWindow = nil; if FirstTime then begin htop := ScreenHeight - hheight - 10; SetRect(HistoRect, hleft, htop, hleft + hwidth, htop + hheight); HistoWindow := NewWindow(nil, HistoRect, 'Histogram', true, NoGrowDocProc, nil, true, 0); WindowPeek(HistoWindow)^.WindowKind := HistoKind; end; if FirstTime or (VideoControl = nil) then SelectWindow(HistoWindow); SetPort(HistoWindow); InvalRect(HistoWindow^.PortRect); SetPort(tPort); end; procedure ShowContinuousHistogram; const skip = 10; var i, NumberOfLines: integer; offset: LongInt; p: ptr; begin for i := 0 to 255 do Histogram[i] := 0; p := ptr(ptr(fgSlotBase)); NumberOfLines := ((fgHeight) div skip) - 1; offset := fgRowBytes * skip; for i := 1 to NumberOfLines do begin DoHistogramOfLine(p, histogram, fgWidth); p := ptr(ord4(p) + offset); end; ThresholdingMode := NoThresholding; HistogramSliceStart := 0; HistogramSliceEnd := 255; ComputeResults; ShowHistogram; end; procedure DoHistogram; var AutoSelectAll: boolean; begin if NotInBounds then exit(DoHistogram); if digitizing then begin if ContinuousHistogram then ContinuousHistogram := false else begin ContinuousHistogram := true; if info <> NoInfo then with info^ do begin RoiType := NoRoi; RoiRect := SrcRect; end; end; exit(DoHistogram) end; AutoSelectAll := not info^.RoiShowing; if AutoSelectAll then SelectAll(false); if (info^.RoiType = RectRoi) and (not RedirectSampling) then GetRectHistogram else GetHistogram; ThresholdingMode := NoThresholding; ComputeResults; ShowCount := false; ShowValues; ShowCount := true; FindThresholdingMode; case ThresholdingMode of DensitySlice: begin HistogramSliceStart := SliceStart; HistogramSliceEnd := SliceEnd; end; GrayMapThresholding: begin HistogramSliceStart := GrayMapThreshold; HistogramSliceEnd := 255; end; BinaryImage, NoThresholding: begin HistogramSliceStart := 0; HistogramSliceEnd := 255; end; end; ShowHistogram; UndoLastMeasurement(false); WhatToUndo := NothingToUndo; if AutoSelectAll then KillRoi; end; {$POP} procedure PlotDensityProfile; var hloc, vloc, value, width, height, i: integer; aLine: LineType; sum: array[0..MaxLine] of real; start, p1, p2: point; begin with info^ do if RoiShowing then case RoiType of LineRoi: begin PlotLineProfile; exit(PlotDensityProfile); end; FreeLineRoi, SegLineRoi, PolygonRoi, FreehandRoi: begin PlotArbitraryLine; exit(PlotDensityProfile); end; end; {case} if NoSelection or NotRectangular or NotInBounds then exit(PlotDensityProfile); ShowWatch; with info^.RoiRect do begin width := right - left; height := bottom - top; start.h := left; start.v := bottom; if (width >= height) or (OptionKeyWasDown) then begin {Column Average Plot} if width > MaxLine then width := MaxLine; for i := 0 to width - 1 do sum[i] := 0.0; for vloc := top to bottom - 1 do begin GetLine(left, vloc, width, aLine); for i := 0 to width - 1 do sum[i] := sum[i] + cvalue[aLine[i]]; end; for i := 0 to width - 1 do PlotData^[i] := sum[i] / height; PlotCount := width; PlotAvg := height; PlotStart.h := left; PlotStart.v := top + (bottom - top) div 2; PlotAngle := 0.0; ComputePlotMinAndMax; if ShowPlot then SetupPlot(start, false); end else begin {Row Average Plot} if height > MaxLine then height := MaxLine; for i := 0 to height - 1 do sum[i] := 0.0; for hloc := left to right - 1 do begin GetColumn(hloc, top, height, aLine); for i := 0 to height - 1 do sum[i] := sum[i] + cValue[aLine[i]]; end; for i := 0 to height - 1 do PlotData^[i] := sum[i] / width; PlotCount := height; PlotAvg := width; PlotStart.h := left + (right - left) div 2; PlotStart.v := top; PlotAngle := 270.0; ComputePlotMinAndMax; if ShowPlot then SetupPlot(start, true); end; end; {with} end; procedure SetScaleUProc (d: DialogPtr; item: integer); {User proc for Set Scale dialog box} var str: str255; VersInfo: str255; r: rect; begin SetPort(d); GetDItemRect(d, item, r); DrawDropBox(r); GetItem(UnitsMenuH, ord(UnitsKind) + 1, str); DrawPopUpText(str, r); end; procedure SetScale; const MeasuredDistanceID = 3; KnownDistanceID = 4; AspectRatioID = 5; ScaleID = 7; UnitsTextID = 8; var mylog: DialogPtr; item, i: integer; SaveUnitsKind, OldUnitsKind, MenuUnitsKind: UnitsType; KnownDistance, MeasuredDistance, SaveScale, TempScale, CalibratedDistance: double; UnitsPerCM, OldUnitsPerCM, SaveRawScale, SaveAspectRatio: double; ignore, MenuItem: integer; str: str255; SaveUnits: UnitType; isLineSelection: boolean; ulength, clength: real; r: rect; begin with info^ do begin if (not RoiShowing) and (CurrentTool = LineTool) and (NoInfo^.roiType = LineRoi) then RestoreRoi; isLineSelection := RoiShowing and (RoiType = LineRoi); InitCursor; if isLineSelection then begin GetLengthOrPerimeter(ulength, clength); MeasuredDistance := ulength; end else MeasuredDistance := 0.0; if not SpatiallyCalibrated then xUnit := 'pixel'; GetUnitsKind(UnitsKind, UnitsPerCM); SaveUnits := xUnit; SaveUnitsKind := UnitsKind; SaveScale := xSpatialScale; SaveAspectRatio := PixelAspectRatio; KnownDistance := 0.0; mylog := GetNewDialog(10, nil, pointer(-1)); SetDReal(MyLog, MeasuredDistanceID, MeasuredDistance, 2); SetDReal(MyLog, KnownDistanceID, KnownDistance, 2); SelIText(MyLog, KnownDistanceID, 0, 32767); SetDReal(MyLog, AspectRatioID, PixelAspectRatio, 4); SetUProc(myLog, UnitsPopupID, @SetScaleUProc); if UnitsKind = pixels then TempScale := 1.0 else TempScale := xSpatialScale; if trunc(TempScale) = TempScale then SetDReal(MyLog, ScaleID, TempScale, 0) else SetDReal(MyLog, ScaleID, TempScale, 5); SetDString(MyLog, UnitsTextID, xUnit); setport(myLog); repeat ModalDialog(nil, item); if item = MeasuredDistanceID then MeasuredDistance := GetDReal(MyLog, MeasuredDistanceID); if item = KnownDistanceID then KnownDistance := GetDReal(MyLog, KnownDistanceID); if item = ScaleID then begin MeasuredDistance := GetDReal(MyLog, ScaleID); KnownDistance := 1; SetDReal(MyLog, MeasuredDistanceID, MeasuredDistance, 2); SetDReal(MyLog, KnownDistanceID, KnownDistance, 2); end; if item = AspectRatioID then begin PixelAspectRatio := GetDReal(MyLog, AspectRatioID); if PixelAspectRatio <= 0.0 then begin beep; PixelAspectRatio := 1.0; end else ySpatialScale := xSpatialScale / PixelAspectRatio; end; if item = UnitsPopUpID then begin OldUnitsKind := UnitsKind; OldUnitsPerCM := UnitsPerCM; GetDItemRect(myLog, item, r); InvertRect(r); MenuItem := PopUpMenu(UnitsMenuH, r.left, r.top, ord(UnitsKind) + 1); InvertRect(r); GetItem(UnitsMenuH, MenuItem, str); DrawPopUpText(str, r); UnitsKind := UnitsType(MenuItem - 1); GetXUnits(UnitsKind); if (UnitsType(MenuItem - 1) = OtherUnits) and (OldUnitsKind <> OtherUnits) then xUnit := 'unit'; SetDString(MyLog, UnitsTextID, xUnit); GetUnitsKind(UnitsKind, UnitsPerCM); if (UnitsPerCM <> OldUnitsPerCM) and (UnitsPerCM <> 0.0) and (OldUnitsPerCM <> 0.0) then begin xSpatialScale := xSpatialScale * (OldUnitsPerCM / UnitsPerCM); ySpatialScale := xSpatialScale / PixelAspectRatio; end; if UnitsKind = Pixels then KnownDistance := 0.0; end; if (item = KnownDistanceID) or (item = MeasuredDistanceID) or (item = ScaleID) then if (UnitsKind = Pixels) and (item <> cancel) then PutMessage('Please select a measurent unit (not pixels) before setting or changing the scale.') else begin if (MeasuredDistance > 0.0) and (KnownDistance > 0.0) then begin xSpatialScale := MeasuredDistance / KnownDistance; ySpatialScale := xSpatialScale / PixelAspectRatio; end; end; if UnitsKind = pixels then TempScale := 1.0 else TempScale := xSpatialScale; if item <> ScaleID then begin if (trunc(TempScale) = TempScale) or (TempScale >= 10000.0) then SetDReal(MyLog, ScaleID, TempScale, 0) else if TempScale < 0.01 then SetDReal(MyLog, ScaleID, TempScale, 6) else SetDReal(MyLog, ScaleID, TempScale, 3); end; if item = UnitsTextID then begin xUnit := GetDString(myLog, item); GetUnitsKind(UnitsKind, UnitsPerCM); GetDItemRect(myLog, UnitsPopUpID, r); InvalRect(r); end; until (item = ok) or (item = cancel); DisposDialog(mylog); if item = cancel then begin xUnit := SaveUnits; UnitsKind := SaveUnitsKind; xSpatialScale := SaveScale; PixelAspectRatio := SaveAspectRatio; end else Changes := true; SpatiallyCalibrated := (xSpatialScale <> 0.0) and (xUnit <> 'pixel'); if not SpatiallyCalibrated then begin UnitsKind := Pixels; UnitsPerCm := 0.0; end; UpdateTitleBar; end; {with info^} end; {$PUSH} {$D-} procedure SetupCalibrationPlot; const hrange = 1024; hmax = 1023; vrange = 600; vmax = 599; SymbolSize = 11; var fRect, tRect: rect; svalue, range, hscale, vscale, MinV, MaxV: extended; tPort: GrafPtr; i, hloc, vloc: integer; SaveClipRegion: RgnHandle; pt: point; begin PlotLeftMargin := 60; PlotTopMargin := 15; PlotBottomMargin := 30; PlotRightMargin := 100; MinV := MinValue; MaxV := MaxValue; for i := 1 to nStandards do begin svalue := StandardValues[i]; if svalue < MinV then MinV := svalue; if svalue > MaxV then MaxV := svalue; end; range := MaxV - MinV; PlotWidth := hrange div 3 + PlotLeftMargin + PlotRightMargin; PlotHeight := vrange div 3 + PlotTopMargin + PlotBottomMargin; PlotLeft := 64; PlotTop := 64; PlotCount := 256; MakePlotWindow(PlotLeft, PlotTop, PlotWidth, PlotHeight); if PlotWindow = nil then exit(SetupCalibrationPlot); WindowPeek(PlotWindow)^.WindowKind := CalibrationPlotKind; SetRect(fRect, -SymbolSize, -SymbolSize, hmax + SymbolSize, vmax + SymbolSize); GetPort(tPort); SetPort(PlotWindow); SaveClipRegion := PlotWindow^.ClipRgn; RectRgn(PlotWindow^.ClipRgn, fRect); hscale := 256 / hrange; vscale := range / vrange; PlotPICT := OpenPicture(fRect); for i := 1 to nStandards do begin hloc := round(umean[i] / hscale); vloc := vmax - round((StandardValues[i] - MinValue) / vscale); SetRect(tRect, hloc - SymbolSize, vloc - SymbolSize, hloc + SymbolSize, vloc + SymbolSize); FrameOval(tRect); end; MoveTo(0, vmax - round((cvalue[0] - MinValue) / vscale)); for i := 1 to 255 do begin hloc := round(i / hscale); vloc := vmax - round((cvalue[i] - MinValue) / vscale); LineTo(hloc, vloc); end; ClosePicture; PlotWindow^.ClipRgn := SaveClipRegion; InvalRect(PlotWindow^.PortRect); SetPort(tPort); SelectWindow(PlotWindow); end; procedure DoCurveFitting; var i: integer; XData, YData, YFit, Residuals, TempData: ColumnVector; Variance: extended; SumResidualsSqr, SumStandards, mean, SumMeanDiffSqr, DegreesOfFreedom: extended; str1, str2: str255; begin with info^ do begin ShowWatch; if fit = RodbardFit then { need to reverse x and y to fit Rodbard equation } for i := 1 to nStandards do begin XData[i] := StandardValues[i]; YData[i] := umean[i]; end else for i := 1 to nStandards do begin XData[i] := umean[i]; YData[i] := StandardValues[i]; end; case fit of StraightLine: nCoefficients := 2; Poly2: nCoefficients := 3; Poly3: nCoefficients := 4; Poly4: nCoefficients := 5; Poly5: nCoefficients := 6; ExpoFit: nCoefficients := 2; PowerFit: nCoefficients := 2; LogFit: nCoefficients := 2; RodbardFit: nCoefficients := 4; end; DegreesOfFreedom := nStandards - nCoefficients; if DegreesOfFreedom < 0 then begin FitGoodness := 0.0; DensityCalibrated := false; NumToString(nCoefficients, str1); case fit of StraightLine: str2 := 'straight line'; Poly2: str2 := '2nd degree polynomial'; Poly3: str2 := '3rd degree polynomial'; Poly4: str2 := '4th degree polynomial'; Poly5: str2 := '5th degree polynomial'; ExpoFit: str2 := 'exponential'; PowerFit: str2 := 'power'; LogFit: str2 := 'log'; RodbardFit: str2 := 'Rodbard'; end; str2 := concat(' standards to do ', str2, ' fitting.'); PutMessage(concat('You need at least ', str1, str2)); exit(DoCurveFitting) end; DoSimplexFit(nStandards, nCoefficients, XData, YData, Coefficient, residuals); DensityCalibrated := true; ZeroClip := true; for i := 1 to nStandards do if ydata[i] < 0.0 then ZeroClip := false; GenerateValues; SumResidualsSqr := 0.0; SumStandards := 0.0; if fit = RodbardFit then for i := 1 to nStandards do begin tempdata[i] := StandardValues[i]; StandardValues[i] := umean[i]; end; for i := 1 to nStandards do begin SumResidualsSqr := SumResidualsSqr + sqr(residuals[i]); SumStandards := SumStandards + StandardValues[i]; end; FitSD := Sqrt(SumResidualsSqr / nStandards); mean := SumStandards / nStandards; SumMeanDiffSqr := 0.0; for i := 1 to nStandards do SumMeanDiffSqr := SumMeanDiffSqr + sqr(StandardValues[i] - Mean); if (SumMeanDiffSqr > 0.0) and (DegreesOfFreedom <> 0) then FitGoodness := 1 - (SumResidualsSqr / DegreesOfFreedom) * ((nStandards - 1) / SumMeanDiffSqr) else FitGoodness := 1.0; if fit = RodbardFit then for i := 1 to nStandards do StandardValues[i] := tempdata[i]; end; info^.changes := true; end; procedure GetStandardsFromFile (mylog: DialogPtr; FirstLevelID, FirstStandardID: integer); var fname, str: str255; RefNum, i, nColumns, nValues: integer; rLine: RealLine; begin RefNum := 0; if not GetTextFile(fname, RefNum) then exit(GetStandardsFromFile); InitTextInput(fname, RefNum); GetLineFromText(rLine, nValues); if nValues = 1 then nColumns := 1 else nColumns := 2; if (nStandards = 0) and (nColumns = 2) then begin i := 0; repeat i := i + 1; if i > MaxStandards then i := MaxStandards; umean[i] := rLine[1]; SetDReal(MyLog, FirstLevelID + i - 1, umean[i], 2); StandardValues[i] := rLine[2]; SetDReal(MyLog, FirstStandardID + i - 1, StandardValues[i], 3); GetLineFromText(rLine, nValues); until nValues = 0; nStandards := i; mCount := nStandards; for i := 1 to mCount do begin ClearResults(i); mean^[i] := umean[i]; end; end else for i := 1 to nStandards do begin if nValues = nColumns then begin StandardValues[i] := rLine[nColumns]; SetDReal(MyLog, FirststandardID + i - 1, StandardValues[i], 3); end; GetLineFromText(rLine, nValues); end; InitCursor; end; procedure SaveStandardsToFile (nStandards: integer); var where: Point; reply: SFReply; i: integer; OptionKeyWasDown: boolean; begin OptionKeyWasDown := OptionKeyDown; where.v := 60; where.h := 100; SFPutFile(Where, 'Save Calibration as?', 'Standards', nil, reply); if reply.good then begin TextBufSize := 0; for i := 1 to nStandards do begin PutReal(umean[i], 1, 3); PutChar(tab); if StandardValues[i] >= 100.0 then PutReal(StandardValues[i], 1, 3) else PutReal(StandardValues[i], 1, 5); if i <> nStandards then PutChar(cr); end; with reply do SaveAsText(fname, vRefNum); end; InitCursor; end; procedure CopyFunctionToLUT; var i: integer; value: LongInt; scale: extended; begin with info^ do begin DisableDensitySlice; scale := 65535.0 / (MaxValue - MinValue); for i := 0 to 255 do begin value := 65535 - round(scale * (cvalue[i] - MinValue)); with cTable[i].rgb do begin red := value; green := value; blue := value; end; end; LoadLUT(cTable); LutMode := CustomGrayScale; SetupPseudocolor; UpdateMap end; end; procedure SetupUncalibratedOD; var i: integer; begin with info^ do begin DensityCalibrated := true; ZeroClip := false; nCoefficients := 0; for i := 1 to 6 do Coefficient[i] := 1.0; fit := UncalibratedOD; GenerateValues; UnitOfMeasure := 'U. OD'; nStandards := 0; end; end; function InvertOD (var temp: StandardsArray): boolean; var i: integer; begin for i := 1 to nStandards do if (StandardValues[i] < 0.000009) or (StandardValues[i] > 4.64) then begin PutMessage('Known OD Values must be in the range 0.00001 to 4.62.'); InvertOD := false; exit(InvertOD); end; for i := 1 to nStandards do {temp[i] := -log10(1.000 - exp10(-StandardValues[i]));} temp[i] := -0.434294481 * ln(1.000 - exp(-2.302585093 * StandardValues[i])); InvertOD := true; end; procedure Calibrate; const FirstLevelID = 3; FirstStandardID = 23; FirstFitID = 63; LastFitID = 74; UnitOfMeasureID = 75; OpenID = 77; SaveID = 78; CopyID = 81; RemoveID = 82; InvertID = 83; var mylog: DialogPtr; ignore, item, i, nBadReals: integer; str: str255; SaveStandards, temp, NewValues: StandardsArray; OptionKeyWasDown, CopyFunction, RemoveCalibration: boolean; begin OptionKeyWasDown := OptionKeyDown; SaveStandards := StandardValues; CopyFunction := false; RemoveCalibration := false; with info^ do begin mylog := GetNewDialog(20, nil, pointer(-1)); nStandards := mCount; if nStandards > MaxStandards then nStandards := MaxStandards; for i := 1 to nStandards do begin SetDReal(MyLog, FirstLevelID + i - 1, umean[i], 2); if StandardValues[i] <> BadReal then SetDReal(MyLog, FirstStandardID + i - 1, StandardValues[i], 3); end; SelIText(MyLog, FirstStandardID, 0, 32767); if (fit = SpareFit1) or (fit = SpareFit2) then fit := Poly3; SetDialogItem(mylog, FirstFitID + ord(fit), 1); if DensityCalibrated then SetDString(MyLog, UnitOfMeasureID, UnitOfMeasure); repeat ModalDialog(nil, item); if (item >= FirstStandardID) and (item < (FirstStandardID + MaxStandards)) then begin i := item - FirstStandardID + 1; if i <= nStandards then StandardValues[i] := GetDReal(MyLog, item) else begin PutMessage('Before entering known values you must use the Measure command to read a set of standards.'); SetDString(MyLog, item, ''); end; end; if (item >= FirstLevelID) and (item < (FirstLevelID + MaxStandards)) then begin i := item - FirstLevelID + 1; if OptionKeyWasDown and (i <= nStandards) then umean[item - FirstLevelID + 1] := GetDReal(MyLog, item) else begin PutMessage('Use the Measure command to record measured values.'); if i <= nStandards then begin RealToString(umean[i], 1, 2, str); SetDString(MyLog, item, str) end else SetDString(MyLog, item, ''); end; end; if (item >= FirstFitID) and (item <= LastFitID) then begin for i := FirstFitID to LastFitID do SetDialogItem(mylog, i, 0); SetDialogItem(mylog, item, 1); fit := CurveFitType(item - FirstFitID); end; if item = UnitOfMeasureID then UnitOfMeasure := GetDString(MyLog, item); if item = OpenID then GetStandardsFromFile(mylog, FirstLevelID, FirstStandardID); if (item = SaveID) and (nStandards > 1) then SaveStandardsToFile(nStandards); if item = CopyID then begin CopyFunction := not CopyFunction; if CopyFunction then RemoveCalibration := false; SetDialogItem(mylog, CopyID, ord(CopyFunction)); SetDialogItem(mylog, RemoveID, ord(RemoveCalibration)); end; if item = RemoveID then begin RemoveCalibration := not RemoveCalibration; if RemoveCalibration then CopyFunction := false; SetDialogItem(mylog, RemoveID, ord(RemoveCalibration)); SetDialogItem(mylog, CopyID, ord(CopyFunction)); end; if (item = InvertID) and (nStandards > 1) then if InvertOD(NewValues) then for i := 1 to nStandards do begin StandardValues[i] := NewValues[i]; SetDReal(MyLog, FirstStandardID + i - 1, StandardValues[i], 5); end; until (item = ok) or (item = cancel); DisposDialog(mylog); if item = cancel then begin StandardValues := SaveStandards; exit(calibrate) end; if RemoveCalibration then begin DensityCalibrated := false; for i := 0 to 255 do cvalue[i] := i; UpdateTitleBar; exit(calibrate) end; nBadReals := 0; if fit = UncalibratedOD then SetupUncalibratedOD else begin for i := 1 to nStandards do if StandardValues[i] = BadReal then nBadReals := nBadReals + 1; if (nStandards > 0) and (nBadReals = 0) then DoCurveFitting else if not DensityCalibrated then beep; end; if DensityCalibrated then begin SetupCalibrationPlot; if CopyFunction then CopyFunctionToLUT; end; UpdateTitleBar; end; {with info^} end; procedure ResetCounter; var AlertID: Integer; begin if UnsavedResults and (not macro) then begin InitCursor; AlertID := alert(500, nil); end else AlertID := ok; if AlertID <> CancelResetID then begin nPoints := 0; nLengths := 0; nAngles := 0; mCount := 0; mCount2 := 0; UnsavedResults := false; ShowValues; if ResultsWindow <> nil then begin with ListTE^^ do TESetSelect(0, teLength, ListTE); TEDelete(ListTE); UpdateResultsScrollBars; end; end; measuring := false; end; procedure ShowResults; const FontSize = 9; var wrect, crect, trect: rect; loc: point; begin mCount2 := mCount; if ResultsWindow <> nil then begin SelectWindow(ResultsWindow); exit(ShowResults); end; CopyResultsToBuffer(1, mCount, true); ShowMessage(''); ResultsWidth := 110 + round(nListColumns * FieldWidth * 6.5); if ResultsWidth < 250 then ResultsWidth := 250; if (ResultsWidth + 20) > ScreenWidth then ResultsWidth := ScreenWidth - 20; ResultsHeight := ((LongInt(TextBufLineCount) * 2) + 2) * FontSize; if ResultsHeight < 200 then ResultsHeight := 200; if (ResultsHeight + ResultsTop + 50) > ScreenHeight then ResultsHeight := ScreenHeight - ResultsTop - 50; SetRect(wrect, ResultsLeft, ResultsTop, ResultsLeft + ResultsWidth, ResultsTop + ResultsHeight); ResultsWindow := NewWindow(nil, wrect, 'Results', true, 0, pointer(-1), true, 0); WindowPeek(ResultsWindow)^.WindowKind := ResultsKind; SetRect(crect, ResultsWidth - ScrollBarWidth, -1, ResultsWidth + 1, ResultsHeight - 14); vScrollBar := NewControl(ResultsWindow, crect, '', true, 0, 0, ResultsHeight - 14, ScrollBarProc, 0); SetRect(crect, -1, ResultsHeight - ScrollBarWidth, ResultsWidth - 14, ResultsHeight + 1); hScrollBar := NewControl(ResultsWindow, crect, '', true, 0, 0, ResultsWidth - 14, ScrollBarProc, 0); InitResultsTextEdit(Monaco, FontSize); DrawControls(ResultsWindow); WhatToUndo := NothingToUndo; end; procedure DoMeasurementOptions; const FirstID = 3; LastID = 15; RedirectID = 22; IncludeHolesID = 23; AutoID = 24; AdjustID = 25; HeadingsID = 26; MaxMeasurementsID = 21; WidthID = 19; PrecisionID = 17; var mylog: DialogPtr; item, i, SavePrecision, SaveMaxMeasurements, SaveWidth: integer; mtype: MeasurementTypes; SaveMeasurements: set of MeasurementTypes; SaveRedirect: boolean; SaveAuto, SaveAdjust, SaveHeadings: boolean; begin InitCursor; if nPoints > 0 then Measurements := Measurements + [XYLocM]; if nLengths > 0 then Measurements := Measurements + [LengthM]; if nAngles > 0 then Measurements := Measurements + [AngleM]; SaveMeasurements := measurements; SaveRedirect := RedirectSampling; SaveWidth := FieldWidth; SavePrecision := precision; SaveAuto := WandAutoMeasure; SaveAdjust := WandAdjustAreas; SaveMaxMeasurements := MaxMeasurements; SaveHeadings := ShowHeadings; mylog := GetNewDialog(4000, nil, pointer(-1)); mtype := AreaM; for i := FirstID to LastID do begin if mtype in measurements then SetDialogItem(mylog, i, 1); if i <> LastID then mtype := succ(mtype); end; SetDialogItem(mylog, RedirectID, ord(RedirectSampling)); SetDialogItem(mylog, IncludeHolesID, ord(IncludeHoles)); SetDialogItem(mylog, AutoID, ord(WandAutoMeasure)); SetDialogItem(mylog, AdjustID, ord(WandAdjustAreas)); SetDialogItem(mylog, HeadingsID, ord(ShowHeadings)); SetDNum(MyLog, MaxMeasurementsID, MaxMeasurements); SetDNum(MyLog, WidthID, FieldWidth); SetDNum(MyLog, PrecisionID, precision); repeat ModalDialog(nil, item); if (item >= FirstID) and (item <= LastID) then begin i := item - FirstID; case i of 0: mtype := AreaM; 1: mtype := MeanM; 2: mtype := StdDevM; 3: mtype := xyLocM; 4: mtype := ModeM; 5: mtype := LengthM; 6: mtype := MajorAxisM; 7: mtype := MinorAxisM; 8: mtype := AngleM; 9: mtype := IntDenM; 10: mtype := MinMaxM; 11: mtype := User1M; 12: mtype := User2M; end; if mtype in measurements then begin measurements := measurements - [mtype]; SetDialogItem(mylog, item, 0) end else begin measurements := measurements + [mtype]; SetDialogItem(mylog, item, 1) end; end; if item = RedirectID then begin RedirectSampling := not RedirectSampling; SetDialogItem(mylog, RedirectID, ord(RedirectSampling)); end; if item = IncludeHolesID then begin IncludeHoles := not IncludeHoles; SetDialogItem(mylog, IncludeHolesID, ord(IncludeHoles)); end; if item = AutoID then begin WandAutoMeasure := not WandAutoMeasure; SetDialogItem(mylog, AutoID, ord(WandAutoMeasure)); end; if item = AdjustID then begin WandAdjustAreas := not WandAdjustAreas; SetDialogItem(mylog, AdjustID, ord(WandAdjustAreas)); end; if item = HeadingsID then begin ShowHeadings := not ShowHeadings; SetDialogItem(mylog, HeadingsID, ord(ShowHeadings)); end; if item = WidthID then FieldWidth := GetDNum(MyLog, WidthID); if item = PrecisionID then precision := GetDNum(MyLog, PrecisionID); if item = MaxMeasurementsID then MaxMeasurements := GetDNum(MyLog, MaxMeasurementsID); until (item = ok) or (item = cancel); DisposDialog(mylog); if (FieldWidth < 1) or (FieldWidth > 18) then begin FieldWidth := SaveWidth; beep; end; if (precision < 0) or (precision > 8) then begin precision := SavePrecision; beep; end; if (MaxMeasurements < 1) or (MaxMeasurements > MaxMaxRegions) then begin MaxMeasurements := SaveMaxMeasurements; beep; end; if item = cancel then begin measurements := SaveMeasurements; RedirectSampling := SaveRedirect; FieldWidth := SaveWidth; precision := SavePrecision; WandAutoMeasure := SaveAuto; WandAdjustAreas := SaveAdjust; MaxMeasurements := SaveMaxMeasurements; ShowHeadings := SaveHeadings; end; if not (XYLocM in Measurements) then nPoints := 0; if not (LengthM in Measurements) then nLengths := 0; if not (AngleM in Measurements) then nAngles := 0; UpdateFitEllipse; if MaxMeasurements <> SaveMaxMeasurements then PutMessage('You must "Record Preferences" and restart before the change to Maximum Particles will take effect.'); if (Measurements <> SaveMeasurements) or (SaveWidth <> FieldWidth) or (SavePrecision <> Precision) then UpdateList; end; procedure UpdateRoiLineWidth; begin with info^, info^.RoiRect do if RoiShowing and (RoiType = LineRoi) then begin LX1 := left + LX1; LY1 := top + LY1; LX2 := left + LX2; LY2 := top + LY2; MakeRegion; end; end; procedure DoProfilePlotOptions; const FixedScaleID = 7; MinID = 8; MaxID = 9; FixedSizeID = 10; WidthID = 11; HeightID = 12; LineWidthID = 13; LinePlotID = 14; ScatterPlotID = 15; InvertID = 16; LabelsID = 17; var mylog: DialogPtr; item, i: integer; SaveAutoscale, SaveLinePlot, SaveInvert, SaveDrawLabels, SaveFixedSize: boolean; SaveWidth, SaveHeight, SaveLineWidth, SaveLineIndex: integer; SaveMin, SaveMax: extended; begin InitCursor; SaveAutoscale := AutoscalePlots; SaveLinePlot := LinePlot; SaveInvert := InvertPlots; SaveMin := ProfilePlotMin; SaveMax := ProfilePlotMax; SaveLineWidth := LineWidth; SaveLineIndex := LineIndex; mylog := GetNewDialog(5000, nil, pointer(-1)); SetDialogItem(mylog, FixedScaleID, ord(not AutoscalePlots)); SetDReal(MyLog, MinID, ProfilePlotMin, 2); SetDReal(MyLog, MaxID, ProfilePlotMax, 2); SetDialogItem(mylog, FixedSizeID, ord(FixedSizePlot)); SetDNum(MyLog, WidthID, ProfilePlotWidth); SetDNum(MyLog, HeightID, ProfilePlotHeight); if LinePlot then SetDialogItem(mylog, LinePlotID, 1) else SetDialogItem(mylog, ScatterPlotID, 1); if InvertPlots then SetDialogItem(mylog, InvertID, 1); if DrawPlotLabels then SetDialogItem(mylog, LabelsID, 1); SetDNum(MyLog, LineWidthID, LineWidth); repeat ModalDialog(nil, item); if item = FixedScaleID then begin AutoscalePlots := not AutoscalePlots; SetDialogItem(mylog, FixedScaleID, ord(not AutoscalePlots)); end; if item = MinID then begin ProfilePlotMin := GetDReal(MyLog, MinID); AutoscalePlots := false; SetDialogItem(mylog, FixedScaleID, 1); end; if item = MaxID then begin ProfilePlotMax := GetDReal(MyLog, MaxID); AutoscalePlots := false; SetDialogItem(mylog, FixedScaleID, 1); end; if item = FixedSizeID then begin FixedSizePlot := not FixedSizePlot; SetDialogItem(mylog, FixedSizeID, ord(FixedSizePlot)); end; if item = WidthID then begin ProfilePlotWidth := GetDNum(MyLog, WidthID); if (ProfilePlotWidth < 0) or (ProfilePlotWidth > 1023) then begin ProfilePlotWidth := SaveWidth; SetDNum(MyLog, WidthID, ProfilePlotWidth); end; FixedSizePlot := true; SetDialogItem(mylog, FixedSizeID, 1); end; if item = HeightID then begin ProfilePlotHeight := GetDNum(MyLog, HeightID); if (ProfilePlotHeight < 0) or (ProfilePlotHeight > 1023) then begin ProfilePlotHeight := SaveHeight; SetDNum(MyLog, HeightID, ProfilePlotHeight); end; FixedSizePlot := true; SetDialogItem(mylog, FixedSizeID, 1); end; if (item = LinePlotID) or (item = ScatterPlotID) then begin SetDialogItem(mylog, LinePlotID, 0); SetDialogItem(mylog, ScatterPlotID, 0); SetDialogItem(mylog, item, 1); LinePlot := item = LinePlotID; end; if item = InvertID then begin InvertPlots := not InvertPlots; SetDialogItem(mylog, InvertID, ord(InvertPlots)); end; if item = LabelsID then begin DrawPlotLabels := not DrawPlotLabels; if DrawPlotLabels then {Attempt to fix a "sticky" check box bug.} SetDialogItem(mylog, LabelsID, 1) else SetDialogItem(mylog, LabelsID, 0); end; if item = LineWidthID then begin LineWidth := GetDNum(MyLog, LineWidthID); if (LineWidth < 1) or (LineWidth > 500) then begin LineWidth := SaveLineWidth; SetDNum(MyLog, LineWidthID, LineWidth); end; ShowLineWidth; end; until (item = ok) or (item = cancel); DisposDialog(mylog); if item = cancel then begin AutoscalePlots := SaveAutoscale; LinePlot := SaveLinePlot; InvertPlots := SaveInvert; ProfilePlotMin := SaveMin; ProfilePlotMax := SaveMax; DrawPlotLabels := SaveDrawLabels; LineWidth := SaveLineWidth; if LineIndex <> SaveLineIndex then begin LineIndex := SaveLineIndex; DrawTools; end; end; if LineWidth <> SaveLineWidth then UpdateRoiLineWidth; if ProfilePlotMax <= ProfilePlotMin then begin beep; ProfilePlotMin := SaveMin; ProfilePlotMax := SaveMax; end; end; procedure DoPoints (event: EventRecord); var loc, tloc: point; hloc, vloc, y, offset: integer; r: rect; str, str1, str2: str255; Decrement: boolean; begin Decrement := false; SetPort(GrafPtr(info^.osPort)); pmForeColor(ForegroundIndex); loc := event.where; ScreenToOffscreen(loc); with loc do begin hloc := h; vloc := v; end; with results, Info^ do begin nPoints := nPoints + 1; IncrementCounter; if InvertYCoordinates then y := info^.PicRect.bottom - vloc - 1 else y := vloc; ClearResults(mCount); PixelCount^[mCount] := 1; if SpatiallyCalibrated then mArea^[mCount] := 1 / xSpatialScale * ySpatialScale else mArea^[mCount] := 1; mean^[mCount] := cvalue[MyGetPixel(hloc, vloc)]; with info^ do if SpatiallyCalibrated then begin xcenter^[mCount] := hloc / xSpatialScale; ycenter^[mCount] := y / ySpatialScale; end else begin xcenter^[mCount] := hloc; ycenter^[mCount] := y; end; end; PenNormal; if OptionKeyDown then begin NumToString(mCount, str); tloc := loc; tloc.v := tloc.v + CurrentSize div 3; DrawTextString(str, tloc, TeJustCenter); end else begin offset := LineWidth div 2; SetRect(r, hloc - offset, vloc - offset, hloc + offset + 1, vloc + offset + 1); if ShiftKeyDown then begin Decrement := true; EraseOval(r); mcount := mcount - 2; if mcount <= 0 then begin mcount := 0; UnsavedResults := false; end; nPoints := nPoints - 2; if nPoints < 0 then nPoints := 0; end else PaintOval(r); UpdateScreen(r); if ControlKeyDown then with info^ do begin if SpatiallyCalibrated then begin RealToString(hloc / xSpatialScale, 1, Precision, str1); RealToString(y / ySpatialScale, 1, Precision, str2); end else begin NumToString(hloc, str1); NumToString(y, str2); end; tloc := loc; with tloc do begin h := h + offset + 5; v := v + CurrentSize div 3; end; str := concat('(', str1, ', ', str2, ')'); DrawTextString(str, tloc, TeJustLeft); end; {Control Key Down} end; ValuesMessage := ''; ShowValues; if Decrement then begin DeleteLines(mcount + 1, mcount + 1); WhatToUndo := NothingToUndo; end else begin AppendResults; if (nPoints = 1) then if not (XYlocM in Measurements) then UpdateList; measuring := true; WhatToUndo := UndoPoint; end; end; procedure FindAngle (event: EventRecord); var start, finish, OldFinish, MidPoint, first: point; ticks: LongInt; x1, y1, x2, y2: integer; angle, angle1, angle2: real; StartRect: rect; FirstLineDone: boolean; begin DrawLabels('Angle:', '', ''); FlushEvents(EveryEvent, 0); start := event.where; Pt2Rect(start, start, StartRect); InsetRect(StartRect, -2, -2); finish := start; SetPort(info^.wptr); PenNormal; PenMode(PatXor); PenSize(1, 1); MoveTo(start.h, start.v); first := start; repeat repeat OldFinish := finish; GetMouse(finish); MoveTo(start.h, start.v); LineTo(OldFinish.h, OldFinish.v); MoveTo(start.h, start.v); LineTo(finish.h, finish.v); ticks := TickCount; while ticks = TickCount do ; x1 := finish.h - start.h; y1 := start.v - finish.v; GetAngle(x1, y1, angle1); Show1Value(angle1, NoValue); until GetNextEvent(mUpMask, event); FirstLineDone := not PtInRect(finish, StartRect); if not FirstLineDone then start := finish; until FirstLineDone; MidPoint := finish; x1 := start.h - MidPoint.h; y1 := MidPoint.v - start.v; GetAngle(x1, y1, angle1); start := finish; finish := start; repeat OldFinish := finish; GetMouse(finish); MoveTo(start.h, start.v); LineTo(OldFinish.h, OldFinish.v); MoveTo(start.h, start.v); LineTo(finish.h, finish.v); ticks := TickCount; while ticks = TickCount do ; x2 := finish.h - MidPoint.h; y2 := MidPoint.v - finish.v; GetAngle(x2, y2, angle2); with results do begin if angle1 >= angle2 then angle := angle1 - angle2 else angle := angle2 - angle1; if angle > 180.0 then angle := 360.0 - angle; Show1Value(angle, NoValue); end; until GetNextEvent(mUpMask, event); nAngles := nAngles + 1; IncrementCounter; ClearResults(mCount); Orientation^[mCount] := angle; ValuesMessage := ''; ShowValues; AppendResults; if nAngles = 1 then UpdateList; repeat until not GetNextEvent(EveryEvent, Event); {FlushEvent doesn't work under A/UX!} xCoordinates^[1] := first.h; yCoordinates^[1] := first.v; xCoordinates^[2] := midpoint.h; yCoordinates^[2] := midpoint.v; xCoordinates^[3] := finish.h; yCoordinates^[3] := finish.v; nCoordinates := 3; MakeNonStraightLineRoi(SegLineRoi); end; procedure SaveBlankField; var SaveInfo: InfoPtr; i, xLines, xPixelsPerLine: integer; src, dst: ptr; SaveFlag: boolean; name: str255; begin if (info^.PictureType = FrameGrabberType) or (info^.PictureType = ScionType) then begin GetWTitle(info^.wptr, name); if pos('(Corrected)', name) > 0 then begin PutMessage('To save a blank field the captured image must be uncorrected.'); exit(SaveBlankField); end; SaveInfo := info; if BlankFieldInfo = nil then begin if not Duplicate('Blank Field', true) then exit(SaveBlankField); end; src := info^.PicBaseAddr; dst := BlankFieldInfo^.PicBaseAddr; with Info^.PicRect do begin xLines := bottom - top; xPixelsPerLine := right - left; end; for i := 1 to xLines do begin BlockMove(src, dst, xPixelsPerLine); src := ptr(ord4(src) + info^.BytesPerRow); dst := ptr(ord4(dst) + xPixelsPerLine); end; Info := BlankFieldInfo; InvertPic; SaveFlag := digitizing; digitizing := false; SelectAll(false); ShowCount := false; Measure; ShowCount := true; digitizing := SaveFlag; BlankFieldMean := round(results.UncalibratedMean); UndoLastMeasurement(false); KillRoi; UpdatePicWindow; info := SaveInfo; SelectWindow(Info^.wptr); end; end; procedure UndoLastMeasurement (DisplayResults: boolean); begin if mCount > 0 then begin if DisplayResults then DeleteLines(mCount, mCount); mCount := mCount - 1; if mCount = 0 then UnsavedResults := false; end else WhatToUndo := NothingToUndo; if DisplayResults then ShowValues; end; function PixelInside (hloc, vloc: integer): boolean; var value: integer; begin value := MyGetPixel(hloc, vloc); case ThresholdingMode of DensitySlice: PixelInside := (value >= SliceStart) and (value <= SliceEnd); GrayMapThresholding: PixelInside := value >= GrayMapThreshold; BinaryImage: PixelInside := value = BlackIndex; end; end; function TraceEdge (hstart, vstart: integer; StartingDirection: char; var TouchingEdge: boolean): boolean; {Traces the points(not pixels) that define the edge of an object using the following} {16 entry lookup table and converts the resulting outline to a QuickDraw region.} {Index 1234* Code Result} {0 0000 X Should never happen} {1 000X R Go Right} {2 00X0 D Go Down} {3 00XX R Go Right} {4 0X00 U Go Up} {5 0X0X U Go Up} {6 0XX0 u Go up or down depending on current direction} {7 0XXX U Go up} {8 X000 L Go left} {9 X00X l Go left or right depending on current direction} {10 X0X0 D Go down} {11 X0XX R Go right} {12 XX00 L Go left} {13 XX0X L Go left} {14 XXX0 D Go down} {15 XXXX X Should never happen} {* 1=Upper left pixel, 2=Upper right pixel, 3=Lower left pixel, 4=Lower right pixel} var count, hloc, vloc, hold, vold, index, SaveBackground: integer; Saveport: GrafPtr; direction, NewDirection: char; table: string[16]; UL, UR, LL, LR, SaveCoordinates: boolean; TempRgn: RgnHandle; begin TouchingEdge := false; table := 'XRDRUUuULlDRLLDX'; GetPort(SavePort); SetPort(GrafPtr(info^.osPort)); if SelectionMode <> NewSelection then TempRgn := NewRgn; with info^ do begin SaveBackground := BackgroundIndex; {We want MyGetPixel to always return 0} BackgroundIndex := WhiteIndex; {for coordinates beyond the edge of the image.} PenNormal; OpenRgn; direction := StartingDirection; hloc := hstart; vloc := vstart; UL := PixelInside(hloc - 1, vloc - 1); UR := PixelInside(hloc, vloc - 1); LL := PixelInside(hloc - 1, vloc); LR := PixelInside(hloc, vloc); hold := hstart; vold := vstart; MoveTo(hstart, vstart); count := 0; SaveCoordinates := ((CurrentTool = wand) or (LengthM in Measurements)) and (not MakingLOI); if SaveCoordinates then begin xCoordinates^[1] := hstart; yCoordinates^[1] := vstart; count := 1; end; repeat if IgnoreParticlesTouchingEdge then with info^.PicRect do TouchingEdge := TouchingEdge or (hloc = left) or (hloc = right) or (vloc = top) or (vloc = bottom); count := count + 1; index := 0; if LR then index := bor(index, 1); if LL then index := bor(index, 2); if UR then index := bor(index, 4); if UL then index := bor(index, 8); NewDirection := table[index + 1]; if NewDirection = 'u' then begin if direction = 'R' then NewDirection := 'U' else NewDirection := 'D' end; if NewDirection = 'l' then begin if direction = 'U' then NewDirection := 'L' else NewDirection := 'R' end; case NewDirection of 'U': begin vloc := vloc - 1; LL := UL; LR := UR; UL := PixelInside(hloc - 1, vloc - 1); UR := PixelInside(hloc, vloc - 1); end; 'D': begin vloc := vloc + 1; UL := LL; UR := LR; LL := PixelInside(hloc - 1, vloc); LR := PixelInside(hloc, vloc); end; 'L': begin hloc := hloc - 1; UR := UL; LR := LL; UL := PixelInside(hloc - 1, vloc - 1); LL := PixelInside(hloc - 1, vloc); end; 'R': begin hloc := hloc + 1; UL := UR; LL := LR; UR := PixelInside(hloc, vloc - 1); LR := PixelInside(hloc, vloc); end; end; LineTo(hloc, vloc); if SaveCoordinates then begin xCoordinates^[count] := hloc; yCoordinates^[count] := vloc; end; hold := hloc; vold := vloc; direction := NewDirection; until ((hloc = hstart) and (vloc = vstart) and (direction = StartingDirection)) or (count >= MaxCoordinates); if SelectionMode <> NewSelection then CloseRgn(TempRgn) else CloseRgn(roiRgn); if count >= MaxCoordinates then begin SetEmptyRgn(roiRgn); SetPort(SavePort); TraceEdge := false; BackgroundIndex := SaveBackground; nCoordinates := 0; exit(TraceEdge); end; if (SelectionMode = AddSelection) then begin if RgnNotTooBig(roiRgn, TempRgn) then UnionRgn(roiRgn, TempRgn, roiRgn); end else if (SelectionMode = SubSelection) then begin if RgnNotTooBig(roiRgn, TempRgn) then DiffRgn(roiRgn, TempRgn, roiRgn); end; RoiShowing := true; roiType := FreehandRoi; if SelectionMode = SubSelection then UpdateScreen(RoiRect); RoiRect := roiRgn^^.rgnBBox; BackgroundIndex := SaveBackground; end; {with info} if SelectionMode <> NewSelection then DisposeRgn(TempRgn); SetPort(SavePort); if SaveCoordinates then begin nCoordinates := count - 1; if CurrentTool = wand then MakeCoordinatesRelative; end; TraceEdge := true; end; procedure MarkSelection (count: integer); var SavePort: GrafPtr; NumWidth, NumLeft, NumBottom, SaveForegroundIndex: integer; RoiWidth, inset, hcenter, vcenter: integer; str: str255; r: rect; OutlineWithEllipse: boolean; xc, yc: extended; begin OutlineWithEllipse := FitEllipse and OptionKeyWasDown; with info^ do begin KillRoi; SetupUndo; WhatToUndo := UndoOutline; GetPort(SavePort); SetPort(GrafPtr(osPort)); SaveForegroundIndex := ForegroundIndex; SetForegroundColor(WhiteIndex); PenNormal; TextFont(ApplFont); TextSize(9); NumToString(count, str); with RoiRect do begin NumWidth := StringWidth(str); if AnalyzingParticles or OutlineWithEllipse then begin xc := xcenter^[count]; yc := ycenter^[count]; if SpatiallyCalibrated then begin xc := xc * xSpatialScale; yc := yc * ySpatialScale; end; hcenter := round(xc); vcenter := round(yc); if InvertYCoordinates then vcenter := PicRect.bottom - vcenter - 1 end else begin hcenter := left + (right - left) div 2; vcenter := top + (bottom - top) div 2; end; NumLeft := hcenter - NumWidth div 2; NumBottom := vcenter + 3; if not BinaryPic and not AnalyzingParticles then begin FrameRgn(roiRgn); if OutlineWithEllipse then DrawEllipse; end; end; PenNormal; SetRect(r, NumLeft - 1, NumBottom - 9, NumLeft + NumWidth + 1, NumBottom + 1); PaintRoundRect(r, 4, 4); MoveTo(NumLeft, NumBottom); TextMode(srcXor); DrawString(str); SetForegroundColor(SaveForegroundIndex); if not analyzingParticles then UpdateScreen(RoiRect); SetPort(SavePort); changes := true; end; end; function isBinaryImage: boolean; var SaveRoiRect: rect; SaveRedirectFlag: boolean; begin with info^ do begin SaveRoiRect := RoiRect; RoiRect := PicRect; if RedirectSampling then GetHistogram else GetRectHistogram; BinaryPic := (histogram[0] + histogram[255]) = LongInt(PixelsPerLine) * nLines; isBinaryImage := BinaryPic; RoiRect := SaveRoiRect; end; end; function SetupAutoOutline (BinaryPixel: boolean): boolean; begin SetupAutoOutline := false; FindThresholdingMode; if (ThresholdingMode = NoThresholding) or MakingLOI then if isBinaryImage or BinaryPixel then ThresholdingMode := BinaryImage; if ThresholdingMode = NoThresholding then begin PutMessage('Sorry, but you must be thresholding, or working with a binary image, to use the wand tool or to do particle analysis.'); exit(SetupAutoOutline); end; if (ThresholdingMode = GrayMapThresholding) and (GrayMapThreshold = 0) then begin PutMessage(' Threshold must be non-zero.'); exit(SetupAutoOutline); end; if not MakingLOI then ShowWatch; SetupAutoOutline := true; end; procedure AutoOutline (start: point); var hloc, vloc: integer; TouchingEdge, BinaryPixel: boolean; direction: char; count: LongInt; Perimeter, CalibratedPerimeter, AspectRatio: real; begin with start do BinaryPixel := (MyGetPixel(h, v) = WhiteIndex) or (MyGetPixel(h, v) = BlackIndex); if not SetupAutoOutline(BinaryPixel) then exit(AutoOutline); if SelectionMode = NewSelection then KillRoi; with info^ do begin with start do if PixelInside(h, v) then begin repeat h := h + 1; until not PixelInside(h, v) or (h >= PicRect.right); if not PixelInside(h - 1, v - 1) then direction := 'R' else if PixelInside(h, v - 1) then direction := 'L' else direction := 'D'; end else begin repeat h := h + 1; until PixelInside(h, v) or (h >= PicRect.right); direction := 'U'; end; if start.h >= PicRect.right then begin beep; exit(AutoOutline); end; if TraceEdge(start.h, start.v, direction, TouchingEdge) then begin WhatToUndo := NothingToUndo; if WandAutoMeasure and not MakingLOI then begin GetHistogram; ComputeResults; if WandAdjustAreas then begin GetLengthOrPerimeter(Perimeter, CalibratedPerimeter); with RoiRect do AspectRatio := (right - left) / (bottom - top); count := PixelCount^[mCount] + round(Perimeter / 2.0 + AspectRatio * 1.5); PixelCount^[mCount] := count; if SpatiallyCalibrated then mArea^[mCount] := count / (xSpatialScale * ySpatialScale) else mArea^[mCount] := count; end; ShowValues; AppendResults; WhatToUndo := UndoMeasurement; if LabelParticles then MarkSelection(mCount); end; if not (WandAutoMeasure and LabelParticles) then RoiShowing := true; if not MakingLOI then UpdateScreen(RoiRect); if not WandAutoMeasure then measuring := false; end; {if} end; {with info} end; procedure RedoMeasurement; var SaveN, temp: integer; Canceled: boolean; begin if not isSelectionTool then begin CurrentTool := SelectionTool; isSelectionTool := true; DrawTools; end; temp := GetInt('Measurement to Redo:', mCount, Canceled); if canceled then exit(RedoMeasurement); MeasurementToRedo := temp; if (MeasurementToRedo >= 1) and (MeasurementToRedo <= mCount) then begin SaveN := mCount; mCount := MeasurementToRedo; ShowValues; mCount := SaveN; end else begin beep; MeasurementToRedo := 0; end; end; procedure DeleteMeasurement; var nToDelete, i: integer; Canceled: boolean; begin nToDelete := GetInt('Measurement to delete:', mCount, Canceled); if (nToDelete >= 1) and (nToDelete <= mCount) and not Canceled then begin for i := nToDelete to mCount - 1 do begin mean^[i] := mean^[i + 1]; sd^[i] := sd^[i + 1]; PixelCount^[i] := PixelCount^[i + 1]; mArea^[i] := mArea^[i + 1]; mode^[i] := mode^[i + 1]; IntegratedDensity^[i] := IntegratedDensity^[i + 1]; idBackground^[i] := idBackground^[i + 1]; xcenter^[i] := xcenter^[i + 1]; ycenter^[i] := ycenter^[i + 1]; MajorAxis^[i] := MajorAxis^[i + 1]; MinorAxis^[i] := MinorAxis^[i + 1]; orientation^[i] := orientation^[i + 1]; mMin^[i] := mMin^[i + 1]; mMax^[i] := mMax^[i + 1]; plength^[i] := plength^[i + 1]; end; {for} mCount := mCount - 1; if mCount = 0 then begin UnsavedResults := false; beep; end; UpdateList; end else if not Canceled then beep; end; function DoAPDialog: boolean; const MinID = 6; MaxID = 7; LabelID = 8; OutlineID = 9; IgnoreID = 10; IncludeHolesID = 11; ResetID = 12; var mylog: DialogPtr; item: integer; begin InitCursor; mylog := GetNewDialog(220, nil, pointer(-1)); SetDNum(MyLog, MinID, MinParticleSize); SetDNum(MyLog, MaxID, MaxParticleSize); SetDialogItem(mylog, IgnoreID, ord(IgnoreParticlesTouchingEdge)); SetDialogItem(mylog, LabelID, ord(LabelParticles)); SetDialogItem(mylog, OutlineID, ord(OutlineParticles)); SetDialogItem(mylog, IncludeHolesID, ord(IncludeHoles)); SetDialogItem(mylog, ResetID, ord(APReset)); repeat ModalDialog(nil, item); if item = MinID then MinParticleSize := GetDNum(MyLog, MinID); if item = MaxID then MaxParticleSize := GetDNum(MyLog, MaxID); if item = IgnoreID then begin IgnoreParticlesTouchingEdge := not IgnoreParticlesTouchingEdge; SetDialogItem(mylog, IgnoreID, ord(IgnoreParticlesTouchingEdge)); end; if item = LabelID then begin LabelParticles := not LabelParticles; SetDialogItem(mylog, LabelID, ord(LabelParticles)); end; if item = OutlineID then begin OutlineParticles := not OutlineParticles; SetDialogItem(mylog, OutlineID, ord(OutlineParticles)); end; if item = IncludeHolesID then begin IncludeHoles := not IncludeHoles; SetDialogItem(mylog, IncludeHolesID, ord(IncludeHoles)); end; if item = ResetID then begin APReset := not APReset; SetDialogItem(mylog, ResetID, ord(APReset)); end; until (item = ok) or (item = cancel); DisposDialog(mylog); if MinParticleSize < 1 then MinParticleSize := 1; if MaxParticleSize > 999999 then MinParticleSize := 999999; if MaxParticleSize <= MinParticleSize then begin MinParticleSize := 1; MaxParticleSize := 999999; end; DoAPDialog := item <> cancel; end; procedure AnalyzeParticles; var hloc, vloc, AlertID, index, MaxTriesPerLine, nParticles: integer; SaveSliceState, TouchingEdge, DrawOutlines, AutoSelectAll, finished, OutsideSelection: boolean; SaveForegroundIndex, SaveBackgroundIndex, EraseIndex, OutlineIndex: integer; tPort: GrafPtr; ScanRect: rect; side: (TopSide, RightSide, BottomSide, LeftSide); dstRgn: rgnHandle; function PixelInside: boolean; var value: integer; offset: LongInt; p: ptr; begin with info^ do begin {MyGetPixel inlined to speed things up.} offset := LongInt(vloc) * BytesPerRow + hloc; p := ptr(ord4(PicBaseAddr) + offset); end; value := BAND(p^, 255); case ThresholdingMode of DensitySlice: PixelInside := (value >= SliceStart) and (value <= SliceEnd); GrayMapThresholding: PixelInside := value >= GrayMapThreshold; BinaryImage: PixelInside := value = BlackIndex; end; end; procedure LabelBlobs; var i: integer; begin if nParticles <= MaxMeasurements then for i := 1 to mCount do begin MarkSelection(i); if i mod 50 = 0 then UpdatePicWindow; if CommandPeriod then begin beep; leave; end; end; end; begin with info^ do begin if NotInBounds or NoUndo then exit(AnalyzeParticles); if not SetupAutoOutline(false) then exit(AnalyzeParticles); if RedirectSampling then begin SetupRedirectedSampling; if InfoForRedirect = nil then exit(AnalyzeParticles) end; if not macro and not OptionKeyWasDown then if not DoAPDialog then exit(AnalyzeParticles); AutoSelectAll := not RoiShowing; if AutoSelectAll then SelectAll(false); ScanRect := RoiRect; if not AutoSelectAll then with ScanRect do begin left := picrect.left; right := PicRect.right; end; KillRoi; if APReset then begin ResetCounter; if mCount > 0 then exit(AnalyzeParticles); end; UpdatePicWindow; SetupUndoFromClip; SaveSliceState := DensitySlicing; SaveForegroundIndex := ForegroundIndex; SaveBackgroundIndex := BackgroundIndex; SetForegroundColor(WhiteIndex); DensitySlicing := false; DrawOutlines := false; case ThresholdingMode of DensitySlice: begin EraseIndex := SliceStart - 1; if EraseIndex < 0 then EraseIndex := WhiteIndex; DrawOutlines := OutlineParticles; OutLineIndex := BlackIndex; end; GrayMapThresholding: begin EraseIndex := GrayMapThreshold - 1; if EraseIndex < 0 then EraseIndex := WhiteIndex; end; BinaryImage: begin DrawOutlines := OutlineParticles; OutLineIndex := 254; EraseIndex := 128; end; end; AnalyzingParticles := true; nParticles := 0; GetPort(tPort); SetPort(GrafPtr(osPort)); dstRgn := NewRgn; SelectionMode := NewSelection; ShowWatch; with ScanRect do for vloc := top to bottom - 1 do for hloc := left to right - 1 do begin if PixelInside then begin if TraceEdge(hloc, vloc, 'U', TouchingEdge) then begin nParticles := nParticles + 1; RoiShowing := false; if mCount < MaxMeasurements then begin GetHistogram; ComputeResults; end; SetBackgroundColor(EraseIndex); EraseRgn(roiRgn); if AutoSelectAll then OutSideSelection := false else begin SectRgn(roiRgn, NoInfo^.RoiRgn, dstRgn); OutSideSelection := EmptyRgn(dstRgn); end; if (PixelCount^[mCount] < MinParticleSize) or (PixelCount^[mCount] > MaxParticleSize) or TouchingEdge or OutsideSelection then begin mCount := mCount - 1; nParticles := nParticles - 1; UpdateScreen(RoiRect); end else begin if DrawOutlines then begin SetForegroundColor(OutlineIndex); FrameRgn(roiRgn); end; UpdateScreen(RoiRect); if nParticles <= MaxMeasurements then begin ShowValues; AppendResults; end else ShowMessage(long2str(nParticles)); if nParticles = MaxMeasurements then beep; if CommandPeriod or (AnalyzingParticles = false) then begin {quit} beep; SetPort(tPort); if LabelParticles then LabelBlobs; DensitySlicing := SaveSliceState; SetForegroundColor(SaveForegroundIndex); SetBackgroundColor(SaveBackgroundIndex); KillRoi; UpdatePicWindow; WhatToUndo := UndoEdit; UndoFromClip := true; AnalyzingParticles := false; DisposeRgn(dstRgn); exit(AnalyzeParticles); end; {quit} end; end; {if TraceEdge} end; {if PixelInside} end; {for} end; {with} SetPort(tPort); if LabelParticles then LabelBlobs; DensitySlicing := SaveSliceState; SetForegroundColor(SaveForegroundIndex); SetBackgroundColor(SaveBackgroundIndex); KillRoi; UpdatePicWindow; if ThresholdingMode = GrayMapThresholding then ResetGrayMap; WhatToUndo := UndoEdit; UndoFromClip := true; AnalyzingParticles := false; DisposeRgn(dstRgn); end; procedure MakeNonStraightLineRoi (RoiKind: RoiTypeType); var i, ff: integer; SaveInfo: InfoPtr; pt, spt, start: point; begin SetupUndoInfoRec; SaveInfo := Info; Info := UndoInfo; with info^ do begin magnification := SaveInfo^.magnification; SrcRect := SaveInfo^.SrcRect; BinaryPic := true; SetPort(GrafPtr(osPort)); end; pmForeColor(BlackIndex); pmBackColor(WhiteIndex); PenNormal; PenSize(LineWidth, LineWidth); EraseRect(info^.PicRect); ff := LineWidth div 2; if ff < 0 then ff := 0; MakingLOI := true; ConvertCoordinates; spt.h := xCoordinates^[1]; spt.v := yCoordinates^[1]; MoveTo(spt.h - ff, spt.v - ff); for i := 2 to nCoordinates do begin pt.h := xCoordinates^[i]; pt.v := yCoordinates^[i]; LineTo(pt.h - ff, pt.v - ff); end; start := spt; start.h := start.h - 1; AutoOutline(start); MakingLOI := false; info^.RoiShowing := false; Info := SaveInfo; with info^ do begin CopyRgn(UndoInfo^.roiRgn, roiRgn); RoiRect := UndoInfo^.RoiRect; SetEmptyRgn(UndoInfo^.roiRgn); RoiShowing := true; SetupUndo; roiType := RoiKind; with RoiRect do begin LX1 := spt.h - left; LY1 := spt.v - top; LX2 := pt.h - left; LY2 := pt.v - top; end; end; {with info^} MakeCoordinatesRelative; end; end. 
